home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 1999 #2 / Amiga Plus CD - 1999 - No. 2.iso / System-Boost / Workbench / ToolManager / Source / Prefs / image.c < prev    next >
C/C++ Source or Header  |  1998-06-17  |  10KB  |  346 lines
  1. /*
  2.  * image.c  V3.1
  3.  *
  4.  * TM Image object class
  5.  *
  6.  * Copyright (C) 1990-98 Stefan Becker
  7.  *
  8.  * This source code is for educational purposes only. You may study it
  9.  * and copy ideas or algorithms from it for your own projects. It is
  10.  * not allowed to use any of the source codes (in full or in parts)
  11.  * in other programs. Especially it is not allowed to create variants
  12.  * of ToolManager or ToolManager-like programs from this source code.
  13.  *
  14.  */
  15.  
  16. #include "toolmanager.h"
  17.  
  18. /* Local data */
  19. #define PROPCHUNKS 3
  20. static const ULONG PropChunkTable[2 * PROPCHUNKS] = {
  21.  ID_TMIM, ID_DATA,
  22.  ID_TMIM, ID_FILE,
  23.  ID_TMIM, ID_NAME,
  24. };
  25. static const char *TextTitle;
  26. static const char *TextFile;
  27. static const char *HelpFile;
  28.  
  29. /* Image class instance data */
  30. struct ImageClassData {
  31.  const char *icd_File;
  32.  Object     *icd_Active;
  33.  Object     *icd_PopFile;
  34. };
  35. #define TYPED_INST_DATA(cl, o) ((struct ImageClassData *) INST_DATA((cl), (o)))
  36.  
  37. /* Image class method: OM_NEW */
  38. #undef  DEBUGFUNCTION
  39. #define DEBUGFUNCTION ImageClassNew
  40. static ULONG ImageClassNew(Class *cl, Object *obj, struct opSet *ops)
  41. {
  42.  IMAGE_LOG((LOG1(Tags, "0x%08lx", ops->ops_AttrList),
  43.             PrintTagList(ops->ops_AttrList)))
  44.  
  45.  /* Create object */
  46.  if (obj = (Object *) DoSuperNew(cl, obj,
  47.                                        MUIA_Window_Title, TextTitle,
  48.                                        MUIA_HelpNode,     "ImageWindow",
  49.                                        TMA_Type,          TMOBJTYPE_IMAGE,
  50.                                        TAG_MORE,          ops->ops_AttrList)) {
  51.   struct ImageClassData *icd = TYPED_INST_DATA(cl, obj);
  52.  
  53.   /* Initialize instance data */
  54.   icd->icd_File   = NULL;
  55.   icd->icd_Active = NULL;
  56.  }
  57.  
  58.  IMAGE_LOG(LOG1(Result, "0x%08lx", obj))
  59.  
  60.  /* Return pointer to created object */
  61.  return((ULONG) obj);
  62. }
  63.  
  64. /* Image class method: OM_DISPOSE */
  65. #undef  DEBUGFUNCTION
  66. #define DEBUGFUNCTION ImageClassDispose
  67. static ULONG ImageClassDispose(Class *cl, Object *obj, Msg msg)
  68. {
  69.  struct ImageClassData *icd = TYPED_INST_DATA(cl, obj);
  70.  
  71.  IMAGE_LOG(LOG1(Disposing, "0x%08lx", obj))
  72.  
  73.  /* Free instance data */
  74.  if (icd->icd_File) FreeVector(icd->icd_File);
  75.  
  76.  /* Call SuperClass */
  77.  return(DoSuperMethodA(cl, obj, msg));
  78. }
  79.  
  80. /* Image class method: TMM_Finish */
  81. #undef  DEBUGFUNCTION
  82. #define DEBUGFUNCTION ImageClassFinish
  83. static ULONG ImageClassFinish(Class *cl, Object *obj, struct TMP_Finish *tmpf)
  84. {
  85.  struct ImageClassData *icd = TYPED_INST_DATA(cl, obj);
  86.  
  87.  IMAGE_LOG(LOG1(Type, "%ld", tmpf->tmpf_Type))
  88.  
  89.  /* MUI objects allocated? */
  90.  if (icd->icd_Active) {
  91.  
  92.   /* Use or Cancel? */
  93.   if (tmpf->tmpf_Type == TMV_Finish_Use) {
  94.  
  95.    /* Get new file name */
  96.    icd->icd_File = GetStringContents(icd->icd_PopFile, icd->icd_File);
  97.   }
  98.  
  99.   /* Reset pointer to file name area */
  100.   icd->icd_Active = NULL;
  101.  }
  102.  
  103.  /* Call SuperClass */
  104.  return(DoSuperMethodA(cl, obj, (Msg) tmpf));
  105. }
  106.  
  107. /* Image class method: TMM_Edit */
  108. #undef  DEBUGFUNCTION
  109. #define DEBUGFUNCTION ImageClassEdit
  110. static ULONG ImageClassEdit(Class *cl, Object *obj, struct TMP_Edit *tmpe)
  111. {
  112.  struct ImageClassData *icd = TYPED_INST_DATA(cl, obj);
  113.  
  114.  /* MUI objects allocated? */
  115.  if (icd->icd_Active) {
  116.  
  117.   IMAGE_LOG(LOG0(Object already active))
  118.  
  119.   /* Yes, forward method to SuperClass */
  120.   DoSuperMethodA(cl, obj, (Msg) tmpe);
  121.  
  122.  /* No, create object edit area */
  123.  } else if (icd->icd_Active =
  124.     HGroup,
  125.      Child, Label2(TextFile),
  126.      Child, icd->icd_PopFile = TMPopFile(TextGlobalSelectFile, icd->icd_File,
  127.                                          LENGTH_FILENAME, HelpFile),
  128.      End,
  129.     End) {
  130.  
  131.   IMAGE_LOG(LOG1(File Area, "0x%08lx", icd->icd_Active))
  132.  
  133.   /* Forward method to SuperClass */
  134.   if (DoSuperMethod(cl, obj, TMM_Edit, icd->icd_Active) == NULL) {
  135.  
  136.    /* SuperClass failed, delete file area again */
  137.    MUI_DisposeObject(icd->icd_Active);
  138.    icd->icd_Active = NULL;
  139.   }
  140.  }
  141.  
  142.  IMAGE_LOG(LOG1(Result, "0x%08lx", icd->icd_Active))
  143.  
  144.  /* Return pointer to file area object to indicate success */
  145.  return((ULONG) icd->icd_Active);
  146. }
  147.  
  148. /* Image class method: TMM_ParseIFF */
  149. #undef  DEBUGFUNCTION
  150. #define DEBUGFUNCTION ImageClassParseIFF
  151. static ULONG ImageClassParseIFF(Class *cl, Object *obj,
  152.                                 struct TMP_ParseIFF *tmppi)
  153. {
  154.  BOOL rc = FALSE;
  155.  
  156.  IMAGE_LOG(LOG1(Handle, "0x%08lx", tmppi->tmppi_IFFHandle))
  157.  
  158.  /* Initialize IFF parser */
  159.  if ((PropChunks(tmppi->tmppi_IFFHandle, PropChunkTable, PROPCHUNKS) == 0) &&
  160.      (StopOnExit(tmppi->tmppi_IFFHandle, ID_TMIM, ID_FORM) == 0) &&
  161.      (ParseIFF(tmppi->tmppi_IFFHandle, IFFPARSE_SCAN) == IFFERR_EOC)) {
  162.   struct StoredProperty *spname;
  163.  
  164.   IMAGE_LOG(LOG0(FORM TMEX chunk parsed OK))
  165.  
  166.   /* Check for mandatory NAME property */
  167.   if (spname = FindProp(tmppi->tmppi_IFFHandle, ID_TMIM, ID_NAME)) {
  168.    struct StoredProperty *spdata;
  169.  
  170.    IMAGE_LOG(LOG2(Name, "%s (0x%08lx)", spname->sp_Data, spname->sp_Data))
  171.  
  172.    /* Check for mandatory DATA property */
  173.    if (spdata = FindProp(tmppi->tmppi_IFFHandle, ID_TMIM, ID_DATA)) {
  174.     struct ImageClassData    *icd = TYPED_INST_DATA(cl, obj);
  175.     struct StandardDATAChunk *sdc = spdata->sp_Data;
  176.  
  177.     IMAGE_LOG(LOG1(Data, "ID 0x%08lx", sdc->sdc_ID))
  178.  
  179.     /* Set new name and ID */
  180.     SetAttrs(obj, TMA_Name, spname->sp_Data,
  181.                   TMA_ID,   sdc->sdc_ID,
  182.                   TAG_DONE);
  183.  
  184.     /* Get file name */
  185.     icd->icd_File = ReadStringProperty(tmppi->tmppi_IFFHandle, ID_TMIM,
  186.                                        ID_FILE);
  187.  
  188.     /* All OK */
  189.     rc = TRUE;
  190.    }
  191.   }
  192.  }
  193.  
  194.  IMAGE_LOG(LOG1(Result, "%ld", rc))
  195.  
  196.  return(rc);
  197. }
  198.  
  199. /* Image class method: TMM_WriteIFF */
  200. #undef  DEBUGFUNCTION
  201. #define DEBUGFUNCTION ImageClassWriteIFF
  202. static ULONG ImageClassWriteIFF(Class *cl, Object *obj,
  203.                                 struct TMP_WriteIFF *tmpwi)
  204. {
  205.  struct StandardDATAChunk sdc;
  206.  BOOL                     rc;
  207.  
  208.  IMAGE_LOG(LOG1(IFFHandle, "0x%08lx", tmpwi->tmpwi_IFFHandle))
  209.  
  210.  /* Initialize DATA chunk */
  211.  sdc.sdc_ID    = (ULONG) obj; /* Use objects address as ID */
  212.  sdc.sdc_Flags = 0;
  213.  
  214.  /* a) Forward message to SuperClass first */
  215.  /* b) Push DATA chunk                     */
  216.  /* c) Push FILE chunk                     */
  217.  rc = DoSuperMethodA(cl, obj, (Msg) tmpwi)                    &&
  218.       WriteProperty(tmpwi->tmpwi_IFFHandle, ID_DATA, &sdc,
  219.                     sizeof(struct StandardDATAChunk))         &&
  220.       WriteStringProperty(tmpwi->tmpwi_IFFHandle, ID_FILE,
  221.                           TYPED_INST_DATA(cl, obj)->icd_File);
  222.  
  223.  IMAGE_LOG(LOG1(Result, "%ld", rc))
  224.  
  225.  return(rc);
  226. }
  227.  
  228. /* Image class method: TMM_WBArg */
  229. #undef  DEBUGFUNCTION
  230. #define DEBUGFUNCTION ImageClassWBArg
  231. static ULONG ImageClassWBArg(Class *cl, Object *obj, struct TMP_WBArg *tmpwa)
  232. {
  233.  ULONG rc;
  234.  
  235.  IMAGE_LOG(LOG1(WBArg, "0x%08lx", tmpwa->tmpwa_Argument))
  236.  
  237.  /* First forward method to SuperClass */
  238.  if (rc = DoSuperMethodA(cl, obj, (Msg) tmpwa)) {
  239.   struct WBArg          *wa   = tmpwa->tmpwa_Argument;
  240.   char                  *file;
  241.  
  242.   IMAGE_LOG(LOG0(Set gadget contents))
  243.  
  244.   /* Allocate memory for buffer */
  245.   if (file = GetMemory(LENGTH_FILENAME)) {
  246.  
  247.    IMAGE_LOG(LOG1(Buffer, "0x%08lx", file))
  248.  
  249.    /* Create file name from lock and name */
  250.    if (NameFromLock(wa->wa_Lock, file, LENGTH_FILENAME) &&
  251.        AddPart(file, wa->wa_Name, LENGTH_FILENAME)) {
  252.  
  253.     IMAGE_LOG(LOG1(File name, "%s", file))
  254.  
  255.     /* Set directory gadget contents */
  256.     SetAttrs(TYPED_INST_DATA(cl, obj)->icd_PopFile, MUIA_String_Contents, file,
  257.                                                     TAG_DONE);
  258.    }
  259.  
  260.    /* Free buffer */
  261.    FreeMemory(file, LENGTH_FILENAME);
  262.   }
  263.  }
  264.  
  265.  IMAGE_LOG(LOG1(Result, "0x%08lx", rc))
  266.  
  267.  return(rc);
  268. }
  269.  
  270. /* Image class method dispatcher */
  271. #undef  DEBUGFUNCTION
  272. #define DEBUGFUNCTION ImageClassDispatcher
  273. __geta4 static ULONG ImageClassDispatcher(__a0 Class *cl, __a2 Object *obj,
  274.                                           __a1 Msg msg)
  275. {
  276.  ULONG rc;
  277.  
  278.  IMAGE_LOG(LOG3(Arguments, "Class 0x%08lx Object 0x%08lx Msg 0x%08lx",
  279.                 cl, obj, msg))
  280.  
  281.  switch(msg->MethodID) {
  282.   /* BOOPSI methods */
  283.   case OM_NEW:
  284.    rc = ImageClassNew(cl, obj, (struct opSet *) msg);
  285.    break;
  286.  
  287.   case OM_DISPOSE:
  288.    rc = ImageClassDispose(cl, obj, msg);
  289.    break;
  290.  
  291.   /* TM methods */
  292.   case TMM_Finish:
  293.    rc = ImageClassFinish(cl, obj, (struct TMP_Finish *) msg);
  294.    break;
  295.  
  296.   case TMM_Edit:
  297.    rc = ImageClassEdit(cl, obj, (struct TMP_Edit *) msg);
  298.    break;
  299.  
  300.   case TMM_ParseIFF:
  301.    rc = ImageClassParseIFF(cl, obj, (struct TMP_ParseIFF *) msg);
  302.    break;
  303.  
  304.   case TMM_WriteIFF:
  305.    rc = ImageClassWriteIFF(cl, obj, (struct TMP_WriteIFF *) msg);
  306.    break;
  307.  
  308.   case TMM_WBArg:
  309.    rc = ImageClassWBArg(cl, obj, (struct TMP_WBArg *) msg);
  310.    break;
  311.  
  312.   /* Unknown method -> delegate to SuperClass */
  313.   default:
  314.    rc = DoSuperMethodA(cl, obj, msg);
  315.    break;
  316.  }
  317.  
  318.  return(rc);
  319. }
  320.  
  321. /* Create Image class */
  322. #undef  DEBUGFUNCTION
  323. #define DEBUGFUNCTION CreateImageClass
  324. struct MUI_CustomClass *CreateImageClass(void)
  325. {
  326.  struct MUI_CustomClass *rc;
  327.  
  328.  /* Create class */
  329.  if (rc = MUI_CreateCustomClass(NULL, NULL, BaseClass,
  330.                                 sizeof(struct ImageClassData),
  331.                                 ImageClassDispatcher)) {
  332.  
  333.   /* Localize strings */
  334.   TextTitle = TranslateString(LOCALE_TEXT_IMAGE_TITLE_STR,
  335.                               LOCALE_TEXT_IMAGE_TITLE);
  336.   TextFile  = TranslateString(LOCALE_TEXT_IMAGE_FILE_STR,
  337.                               LOCALE_TEXT_IMAGE_FILE);
  338.   HelpFile  = TranslateString(LOCALE_HELP_IMAGE_FILE_STR,
  339.                               LOCALE_HELP_IMAGE_FILE);
  340.  }
  341.  
  342.  IMAGE_LOG(LOG1(Result, "0x%08lx", rc))
  343.  
  344.  return(rc);
  345. }
  346.